package util;

import java.lang.reflect.Array;
import java.util.Collection;

import org.apache.commons.lang.ArrayUtils;
import org.springframework.util.Assert;

import bean.BeanUtils;

/**
 * 数组帮助类，他继承了ArrayUtils类
 * 
 * @author:
 *          唐竹
 * @date
 *       创建时间：2011-6-7 上午11:14:08
 *       修改时间：2011-08-08 王永弟 增加数组与数组间的比较
 */
public class ArrayHelper {
	/**
	 * 将数组对象转为化以','分隔的字符串
	 * 
	 * @param array
	 *            数组对象
	 * @return
	 */
	public static String toSimpleString(Object array) {
		return toSimpleString(array, ",");
	}

	/**
	 * @see ArrayUtils#isNotEmpty(Object[])
	 */
	public static boolean isNotEmpty(Object[] array) {
		return ArrayUtils.isNotEmpty(array);
	}

	/**
	 * @see ArrayUtils#isEmpty(Object[])
	 */
	public static boolean isEmpty(Object[] array) {
		return ArrayUtils.isEmpty(array);
	}

	/**
	 * @see ArrayUtils#contains(Object[], Object)
	 */
	public static boolean contains(Object[] array, Object objectToFind) {
		return ArrayUtils.contains(array, objectToFind);
	}

	/**
	 * <方法描述> 判断一个数组是否和另一个数组存在交集
	 * 
	 * @param array
	 *            原数组
	 * @param arrayToFind
	 *            待比较的数组
	 * @return true or false
	 */
	public static boolean containsOne(Object[] array, Object[] arrayToFind) {
		boolean containsOne = false;
		Assert.notNull(arrayToFind);
		for (Object obj : arrayToFind) {
			if (ArrayUtils.contains(array, obj)) {
				containsOne = true;
				break;
			}
		}
		return containsOne;
	}

	/**
	 * <方法描述> 判断一个数组是否是另一个数组的子集
	 * 
	 * @param array
	 *            原数组
	 * @param arrayToFind
	 *            待比较的数组
	 * @return true or false
	 */
	public static boolean containsAll(Object[] array, Object[] arrayToFind) {
		boolean containsAll = true;
		Assert.notNull(arrayToFind);
		for (Object obj : arrayToFind) {
			if (!ArrayUtils.contains(array, obj)) {
				containsAll = false;
				break;
			}
		}
		return containsAll;
	}

	/**
	 * @see ArrayUtils#add(Object[], Object)
	 */
	public static Object[] add(Object[] array, Object element) {
		return ArrayUtils.add(array, element);
	}

	/**
	 * 将数组转化为以参数分割的字符串
	 * 
	 * @param array
	 *            数组对象
	 * @param separator
	 *            分隔符
	 * @return
	 */
	public static String toSimpleString(Object array, String separator) {
		StringBuilder sb = new StringBuilder();
		if (array != null) {
			if (!array.getClass().isArray()) {
				sb.append(array);
			} else {
				for (int i = 0; i < Array.getLength(array); i++) {
					if (sb.length() == 0) {
						sb.append(Array.get(array, i));
					} else {
						sb.append(separator).append(Array.get(array, i));
					}
				}
			}
		}
		return sb.toString();
	}

	/**
	 * 根据指定字段名，将数组对象转为化以','分隔的字符串
	 * 
	 * @param array
	 *            数组对象
	 * @return
	 */
	public static String toStringByField(Object array, String fieldName) {
		Assert.hasLength(fieldName);
		return toStringByField(array, fieldName, ",");
	}

	/**
	 * 根据指定字段名，将数组转化为以参数分割的字符串
	 * 
	 * @param array
	 *            数组对象
	 * @param separator
	 *            分隔符
	 * @return
	 */
	public static String toStringByField(Object array, String fieldName, String separator) {
		Assert.hasLength(fieldName);
		StringBuilder sb = new StringBuilder();
		if (array != null) {
			if (!array.getClass().isArray()) {
				sb.append(BeanUtils.getProperty(array, fieldName));
			} else {
				for (int i = 0; i < Array.getLength(array); i++) {
					if (sb.length() > 0) {
						sb.append(separator);
					}
					sb.append(BeanUtils.getProperty(Array.get(array, i), fieldName));
				}
			}
		}
		return sb.toString();
	}

	/**
	 * 把String类型的集合转化成字符串数组
	 * 
	 * @param collection
	 * @return
	 * @example <调用范例>
	 */
	public static String[] toArrayByCollection(Collection<String> collection) {
		Assert.notEmpty(collection);
		String[] array = new String[collection.size()];
		int i = 0;
		for (String str : collection) {
			array[i++] = str;
		}
		return array;
	}

	/**
	 * 从数组中找到给定类型或其子类型的对象
	 * 
	 * @param objets
	 *            对象数组
	 * @param clazz
	 *            给定类型
	 * @return
	 *         Object 给定类型或其子类型的对象，可能为null
	 * @log
	 *      <YYYY-MM-DD 变更者 变更内容>
	 *      2011-7-8 唐竹 创建
	 */
	@SuppressWarnings("unchecked")
	public static Object findObject(Object[] objets, Class clazz) {
		if (clazz == null)
			return null;
		if (ArrayHelper.isNotEmpty(objets)) {
			for (Object obj : objets) {
				if (obj != null && clazz.isAssignableFrom(obj.getClass())) {
					return obj;
				}
			}
		}
		return null;
	}

	/**
	 * <方法描述>从数组中，删除某个对象的值，返回对象的数组
	 * 
	 * @param <T>
	 * @param objects
	 * @param obj
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static <T> T[] remove(T[] objects, T obj) {
		Assert.notNull(objects);
		for (int i = objects.length - 1; i >= 0; i--) {
			if (objects[i] != null && objects[i].equals(obj)) {
				objects = (T[]) ArrayUtils.remove(objects, i);
			}
		}
		return objects;
	}
}

